/******************************************************************************
*@file     ec_app_param.c
*@brief    系统参数管理，参数的读取和存储
*@author   zhjh
*@version  1.0
*@date     2023年12月22日
*
*@copyright  Copyright (c) 2023 天津柯迪斯科极有限公司 All rights reserved.
*
*@par 修改日志:
*<table>
*<tr><th>Date       <th>Version   <th>Author      <th>Description
*<tr><td>2023年12月22日<td>【版本号】     <td>【作者】     <td>【日志】
*</table>
******************************************************************************/

#include "ec_app.h"
#include "esp_app_desc.h"
#include "esp_ota_ops.h"
// #include "esp_hidd_prf_api.h"
// #include "esp_bt_defs.h"
// #include "esp_gap_ble_api.h"
// #include "esp_gatts_api.h"
// #include "esp_gatt_defs.h"
// #include "esp_bt_main.h"
// #include "esp_bt_device.h"

#define LOG_LOCAL_LEVEL ESP_LOG_DEBUG
#include "esp_log.h"
static char * TAG = {"EC_PARAM->"};
#define DIC_DATA_BUFF_SIZE   1024//可能会因为数据量的加大而修改

//全局变量
nvs_handle_t  nvs_handler;//nvs的句柄
uint32_t cail_vol_ref;
uint32_t cail_photo_ref;


static uint8_t  dic_data_buf[DIC_DATA_BUFF_SIZE] = {0};

int8_t ec_app_enum_value_rw(uint8_t enum_value,void *data,uint8_t data_len,uint8_t r_or_w);//读写单个键得键值
//NVS区存放有5个键值,对应字典枚举变量的数据长度

const uint8_t ec_dic_data_len[DIC_MAX_NUM+1]=
{   
    1,32,4,4,3,//版本参数信息
    1,2,2,1,1,//限速
    1,1,1,1,1,//缓启动方式
    1,1,1,1,1,//助力灵敏度
    1,2,1,1,1,//光感灵敏度等级
    1,11,11,1,1,//挡位信息配置参数
    1,5,1,24,24,24,24,24,10,//电压分段信息
    1,1,3,1,3,1,3,//密码信息
    4,4,2,2,8,8,8,8,8,8,8,8,8,8,//定时存储
    4,4,4,4,4,4,    //校准值
    32,         //蓝牙名字
    32,         //TCU序列号

    1,1,4,2,1,1,//系统状态、SOC、电压值、速度、大灯状态、蓝牙连接状态
    2,1,1,2,1,  //错误代码
    1,1,1,1,1,1,//灯的状态
    
    2,2,1,1,1,1,1,1,1,1,//实时电流
    1,1,1,1,1,  //恢复出厂，清Trip，加减档
    1,1,1,1,1,1,//系统执行动作的指令
    2,2,2,2,1,//控制器温度
    2,2,1,1,1,//踏频
    2,2,1,
    1,2,
    6,1,1,//控制器的参数
    2,
    1
};
/**************************************************配置参数，默认值区域***********************************************/

const uint8_t ec_config_voltage_tab[CONFIG_VOLTAGE_NUM] = CONFIG_VOLTAGE_TAB;
const uint16_t ec_config_voltage_tab_value[5][12] = {CONFIG_VOLTAGE_TAB_1,CONFIG_VOLTAGE_TAB_2,CONFIG_VOLTAGE_TAB_3};

const uint8_t ec_config_vol_perc_tab[10] = CONFIG_VOL_PERC_TAB;//电压百分比表

const uint8_t ec_config_pas_tab[CONFIG_PAS_NUM] = CONFIG_PAS_TAB;
const uint8_t ec_config_pad_pwm_3_tab[3] = CONFIG_PAS_PWM_3;
const uint8_t ec_config_pad_pwm_5_tab[5] = CONFIG_PAS_PWM_5;
const uint8_t ec_config_pad_pwm_7_tab[7] = CONFIG_PAS_PWM_7;
const uint8_t ec_config_pad_pwm_9_tab[9] = CONFIG_PAS_PWM_9;

const uint8_t dic_data_buf_def[DIC_DATA_BUFF_SIZE] = 
{
    CFG_PARAM_VER,
    'S','N', '3', '4', '5', '6', '7', '8',
     '9', '0', '1', '2',0,0,0,0,
    0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,//32字节得SN吗
    0,0,0,0,  0,0,0,0,  0,0,0,
    CONFIG_SPEED_LIMIT,
    (uint16_t)CONFIG_DEF_DIAMETER,(uint16_t)CONFIG_DEF_DIAMETER>>8,
    (uint16_t)(CONFIG_DEF_DIAMETER*2.54*3.14),(uint16_t)(CONFIG_DEF_DIAMETER*2.54*3.14)>>8,
    CONFIG_IDLE_TIME,//自动关机时间
    CONFIG_BOOT_MODE,//启动方式

    CONFIG_START_STRENGTH,//缓启动方式
    0,//开机助力档位
    CONFIG_ASSISTANT_DIR,                       //助力方向
    CONFIG_ASSISTANT_NUM,                       //助力磁钢数
    CONFIG_SPEED_SENSOR,                        //测速磁钢数
    
    CONFIG_SENSITIVITY,                         //助力灵敏度
    CONFIG_KEY_PUSH_EN,                         //按键是否助推
    CONFIG_HANDLE_PUSH,                         //转把是否助推
    CONFIG_HANDLE_SEGEMENT,                     //转把分档
    CONFIG_EXTI_TIME,                           //无设置推出设置界面的时间，单位S
    
    CONFIG_DEF_AL_SENSITIVITY,                  //光感灵敏度等级。光感灵敏度等级0-5级，0xFF:OFF
    (uint16_t)CONFIG_CURRENT_LIMIT,(uint16_t)CONFIG_CURRENT_LIMIT>>8,//限流值2个字节0.1A
    CONFIG_SOC_TYPE,                            //电量显示方式0-百分比，1-电压值
    CONFIG_DEF_UNIT,                            //单位显示，0，是公制，1是英制
    CONFIG_BACKLIGHT_LEVEL,                     //默认背光等级1~5
    
    CONFIG_PAS_NUM,                             //档位数
    0,0,0,0,0,0,0,0,0,0,0,                      //11个挡位值
    0,0,0,0,0,0,0,0,0,0,0,                      //11个档位对应得PWM值
    CONFIG_SPORTS_MODE,                         //运动模式
    0,                                          //解除限速，0，1
    CONFIG_VOLTAGE_NUM,                         //当前系统支持电压数量
    0,0,0,0,0,
    CONFIG_DEF_VOLTAG_INDEX,                    //当前系统电压
    0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0, 0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,
    CONFIG_PASSWORD_LEN,                      //密码长度
    CONFIG_START_PASSWORD_EN,                 //开机密码使能
    0,0,0,
    CONFIG_SETTING_PASSWORD_EN,               //设置密码使能
    0,0,0,
    CONFIG_USER_PASSWORD_EN,                  //用户密码使能
    0,0,0,
    // 0,0,0,0,0,0,
    0,0,0,0,                                    //小计骑行时间，4个字节，单位秒
    0,0,0,0,                                    //总计骑行时间，4个字节，单位秒
    0,0,                                        //最大速度,2个字节，0.1Km/h
    0,0,                                        //平均速度,2个字节，0.1Km/h
    0,0,0,0,0,0,0,0,                            //小里程,8个字节，单位：0.1m
    0,0,0,0,0,0,0,0,                            //总里程,8个字节，单位：0.1m
    0,0,0,0,0,0,0,0,                            //卡路里,8个字节，单位：0.1Kcal
    0,0,0,0,0,0,0,0,                            //卡路里,8个字节，单位：0.1Kcal

    0,0,0,0,0,0,0,0,                            //挡位里程1,8个字节，单位：0.1m
    0,0,0,0,0,0,0,0,                            //挡位里程2,8个字节，单位：0.1m
    0,0,0,0,0,0,0,0,                            //挡位里程3,8个字节，单位：0.1m
    0,0,0,0,0,0,0,0,                            //挡位里程4,8个字节，单位：0.1m
    0,0,0,0,0,0,0,0,                            //挡位里程5,8个字节，单位：0.1m
    0,0,0,0,0,0,0,0,                            //挡位里程6,8个字节，单位：0.1m

    0x9c,0x06,0,0,                                    //电压校准值，4个字节
    0x9c,0x06,0,0,                                    //光感电压校准值，4个字节
    0x9c,0x06,0,0,                                    //霍尔校准值，4个字节
    0x9c,0x06,0,0,                                    //霍尔校准值，4个字节        
    0x9c,0x06,0,0,                                    //转把校准值，4个字节
    0x9c,0x06,0,0,                                    //转把校准值，4个字节     
    'K','D','-',0,0,0,
    0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,//蓝牙名称

    0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,//32个字节的数据
    //实时参数给出默认值
    0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,//32个字节的数据
    
};

//配置默认值参数结束
static char *nvs_key_string[] = {
    ENUM_TO_STR(PARAM_VER),                     //版本号
    ENUM_TO_STR(SN_NUM),                        //仪表的SN号
    ENUM_TO_STR(CONFIG_PARAM),                  //配置参数
    ENUM_TO_STR(VOLTAGE_INFO),                  //电量电压信息
    ENUM_TO_STR(PASSWD_INFO),                   //密码信息
    ENUM_TO_STR(RIDING_INFO),                   //骑行信息
    ENUM_TO_STR(PAS_RIDING_INFO),               //各档位骑行信息
    ENUM_TO_STR(CALI_INFO),                       //校准信息
    ENUM_TO_STR(BLE_INFO),                        //蓝牙信息

};
static char *dic_value_string[] = {
    ENUM_TO_STR(DIC_SYS_PARAM_VER),          //仪表参数版本,1个字节
    ENUM_TO_STR(DIC_SYS_SN),                     //仪表序列号,32个字节
    ENUM_TO_STR(DIC_SYS_SW_VER),                 //仪表软件版本号，4个字节
    ENUM_TO_STR(DIC_SYS_HW_VER),                 //仪表硬件版本号，4字节
    ENUM_TO_STR(DIC_SYS_PRO_SW_VER),             //仪表赛维软件协议版本号。3字节

    ENUM_TO_STR(DIC_SYS_SPEED_LIMIT),            //限速,1个字节，1Km/h
    ENUM_TO_STR(DIC_SYS_WHEEL_CODE),             //轮径，2个字节，0.1in
    ENUM_TO_STR(DIC_SYS_WHEEL_SIZE),             //轮周长，2个字节，0.1cm
    ENUM_TO_STR(DIC_SYS_AUTO_OFF_TIME),          //自动关机时间,1个字节，单位分钟
    ENUM_TO_STR(DIC_SYS_BOOT_MODE),              //启动方式,1个字节，0：零启动，1：非零启动
    ENUM_TO_STR(DIC_SYS_START_STRENGTH),         //缓启动方式，0~3：1-4档，1个字节
    ENUM_TO_STR(DIC_SYS_POWERON_PAS_LEVEL),      //开机助力档位，1，1个字节
    ENUM_TO_STR(DIC_SYS_ASSISTANT_DIR),          //助力方向，0：正向，1：反向，1个字节
    ENUM_TO_STR(DIC_SYS_ASSISTANT_NUM),          //助力磁钢数，1个字节
    ENUM_TO_STR(DIC_SYS_SPEED_SENSOR),           //测速磁钢数，1个字节
    ENUM_TO_STR(DIC_SYS_PAS_SENSITIVITY),        //助力灵敏度，1个字节
    ENUM_TO_STR(DIC_SYS_KEY_PUSH_EN),            //按键是否助推，1个字节
    ENUM_TO_STR(DIC_SYS_HANDLE_PUSH_EN),         //转把是否助推，1个字节
    ENUM_TO_STR(DIC_SYS_HANDLE_SEGEMENT_EN),     //转把分档，1个字节
    ENUM_TO_STR(DIC_SYS_EXTI_TIME),              //无操作退出设置界面时间，单位S，1个字节
    ENUM_TO_STR(DIC_SYS_SENSITIVITY_LEVEL),      //光感灵敏度等级光感灵敏度等级0-5级，0xFF:OFF，1个字节
    ENUM_TO_STR(DIC_SYS_CURRENT_LIMIT),          //限流值，2个字节，单位0.1A
    ENUM_TO_STR(DIC_SYS_SOC_TYPE),               //电量显示方式，百分比电压，1个字节，0-百分比，1-电压值
    ENUM_TO_STR(DIC_SYS_UNIT),                   //显示单位,公英制，1个字节，0，是公制，1是英制
    ENUM_TO_STR(DIC_SYS_BACKLIGHT),              //背光亮度，1个字节

    ENUM_TO_STR(DIC_SYS_PAS_NUM),                //档位数量，1个字节
    ENUM_TO_STR(DIC_SYS_PAS_TAB),                //档位值，11个字节，最大支持11个档
    ENUM_TO_STR(DIC_SYS_PAS_PWM_TAB),            //档位PWM对应表，最大支持11个档
    ENUM_TO_STR(DIC_SYS_SPORTS_MODE),            //运动模式，1个字节
    
    
    ENUM_TO_STR(DIC_SYS_VOLTAGE_NUM),            //系统支持的电压数，1个字节
    ENUM_TO_STR(DIC_SYS_VOLTAGE_TAB),            //系统支持的电压表，5个字节
    ENUM_TO_STR(DIC_SYS_VOLTAGE_INDEX),          //当前系统电压段，1个字节
    ENUM_TO_STR(DIC_SYS_VOLTAGE_TAB_1),          //系统支持的电压分段1，24个字节，每两个字节一个数据，第一个为欠压值，最后一个为超压值
    ENUM_TO_STR(DIC_SYS_VOLTAGE_TAB_2),          //系统支持的电压分段2，24个字节
    ENUM_TO_STR(DIC_SYS_VOLTAGE_TAB_3),          //系统支持的电压分段3，24个字节
    ENUM_TO_STR(DIC_SYS_VOLTAGE_TAB_4),          //系统支持的电压分段4，24个字节
    ENUM_TO_STR(DIC_SYS_VOLTAGE_TAB_5),          //系统支持的电压分段5，24个字节
    ENUM_TO_STR(DIC_SYS_VOLTAGE_PERC_TAB),       //电压百分比对应表，10个字节

    ENUM_TO_STR(DIC_SYS_PASSWORD_LEN),           //密码长度，1个字节
    ENUM_TO_STR(DIC_SYS_POWERON_PASSWORD_EN),    //开机密码使能，1个字节
    ENUM_TO_STR(DIC_SYS_POWERON_PASSWORD),       //开机密码，3个字节，16进制表示，最大支持6位密码
    ENUM_TO_STR(DIC_SYS_SETTING_PASSWORD_EN),    //设置密码使能，1个字节
    ENUM_TO_STR(DIC_SYS_SETTING_PASSWORD),       //设置密码，3个字节，16进制表示，最大支持6位密码
    ENUM_TO_STR(DIC_SYS_USER_PASSWORD_EN),       //设置密码使能，1个字节
    ENUM_TO_STR(DIC_SYS_USER_PASSWORD),          //设置密码，3个字节，16进制表示，最大支持6位密码


    ENUM_TO_STR(DIC_RUN_TRIP_TIME),            //小计骑行时间，4个字节，单位秒
    ENUM_TO_STR(DIC_RUN_TOTAL_TIME),             //总计骑行时间，4个字节，单位秒
    ENUM_TO_STR(DIC_RUN_SPEED_MAX),              //最大速度,2个字节，0.1Km/h
    ENUM_TO_STR(DIC_RUN_SPEED_AVG),              //平均速度,2个字节，0.1Km/h
    ENUM_TO_STR(DIC_RUN_TRIP),                   //总里程,8个字节，单位：0.1m
    ENUM_TO_STR(DIC_RUN_ODO),                    //总里程,8个字节，单位：0.1m

    ENUM_TO_STR(DIC_RUN_ODO_PAS1),               //总里程,8个字节，单位：0.1m
    ENUM_TO_STR(DIC_RUN_ODO_PAS2),               //总里程,8个字节，单位：0.1m
    ENUM_TO_STR(DIC_RUN_ODO_PAS3),               //总里程,8个字节，单位：0.1m
    ENUM_TO_STR(DIC_RUN_ODO_PAS4),               //总里程,8个字节，单位：0.1m
    ENUM_TO_STR(DIC_RUN_ODO_PAS5),               //总里程,8个字节，单位：0.1m
    ENUM_TO_STR(DIC_RUN_ODO_PAS6),               //总里程,8个字节，单位：0.1m


    ENUM_TO_STR(DIC_CALI_VOL_REF),                   //电压校准值，4个字节
    ENUM_TO_STR(DIC_CALI_PHOTO_REF),                 //光感电压校准值，4个字节
    ENUM_TO_STR(DIC_CALI_HULL_MIN_REF),              //霍尔校准值，4个字节
    ENUM_TO_STR(DIC_CALI_HULL_MAX_REF),              //霍尔校准值，4个字节
    ENUM_TO_STR(DIC_CALI_HANDLE_MIN_REF),            //转把校准值，4个字节
    ENUM_TO_STR(DIC_CALI_HANDLE_MAX_REF),            //转把校准值，4个字节

    ENUM_TO_STR(DIC_BLE_NAME),                       //32个字符
    ENUM_TO_STR(DIC_TCU_SN),                       //32个字符

/****************************纯运行参数，不需要保存*****************************/
    ENUM_TO_STR(DIC_RUN_SYS_STATE),                  //系统状态
    ENUM_TO_STR(DIC_RUN_SOC),                        //电量百分比,1个字节，0-100
    ENUM_TO_STR(DIC_RUN_SOC_VOL),                    //电压值，4个字节，mV
    ENUM_TO_STR(DIC_RUN_SPEED),                      //实时速度,2个字节，0.1Km/h
    ENUM_TO_STR(DIC_RUN_LAMP_STATE),                 //大灯状态,1个字节，0关闭，1打开
    ENUM_TO_STR(DIC_RUN_BLE_STATE),                  //蓝牙连接状态,1个字节，0断开，1连接
    ENUM_TO_STR(DIC_RUN_ERR_CODE),              //错误代码，2个字节，
    ENUM_TO_STR(DIC_RUN_PAS),                        //实时档位，1个字节
    ENUM_TO_STR(DIC_RUN_PUSH_STATE),                 //实时助推状态，0：无助推，1：有助推
    ENUM_TO_STR(DIC_RUN_AUTO_POWER_OFF_CNT),         //自动关机计数，2个字节，单位秒
    ENUM_TO_STR(DIC_RUN_HEAD_LIGHT),                 //前灯状态，1个字节
    ENUM_TO_STR(DIC_RUN_REAR_LIGHT),                 //后灯状态，1个字节               
    ENUM_TO_STR(DIC_RUN_LEFT_TURN_LIGHT),            //左转向灯状态，1个字节
    ENUM_TO_STR(DIC_RUN_RIGHT_TURN_LIGHT),           //右转向灯状态，1个字节
    ENUM_TO_STR(DIC_RUN_HORN),                       //喇叭状态，1个字节
    ENUM_TO_STR(DIC_RUN_TAIL_LIGHT),                 //尾灯状态，1个字节，
    ENUM_TO_STR(DIC_RUN_REAR_FOG_LIGHT),             //远光灯状态，1个字节
    ENUM_TO_STR(DIC_RUN_CURRENT),                    //实时电流2个字节，0.01A
    ENUM_TO_STR(DIC_RUN_POWER),                      //实时功率，2个字节，0.1W
    ENUM_TO_STR(DIC_RUN_POWER_PERCENT),              //实时功率百分比，1个字节，0-100%
    ENUM_TO_STR(DIC_RUN_USB_STATE),                  //USB连接状态，0未连接，1已连接
    ENUM_TO_STR(DIC_RUN_BREAK_STATUS),               //刹车状态,1个字节
    ENUM_TO_STR(DIC_RUN_VOERHAUL_FLAG),              //检修标志,1个字节
    ENUM_TO_STR(DIC_RUN_BACK_LIGHT),                 //当前背光等级，1个字节
    ENUM_TO_STR(DIC_RUN_CRUISE_STATE),               //巡航状态，1个字节
    ENUM_TO_STR(DIC_CMD_RESET_TO_DEFAULT),           //恢复出厂设置，1个字节
    ENUM_TO_STR(DIC_CMD_CLEAR_TRIP),                 //清除TRIP，1个字节
    ENUM_TO_STR(DIC_CMD_PLUS_PAS),                   //增加档位，1个字节
    ENUM_TO_STR(DIC_CMD_REDUCE_PAS),                 //减少档位，1个字节
    ENUM_TO_STR(DIC_CMD_TIMING),                     //校时，1个字节
    ENUM_TO_STR(DIC_CMD_CRUISE),                     //巡航指令，1个字节
    ENUM_TO_STR(DIC_CMD_POWER_OFF),                  //关机，1个字节
    ENUM_TO_STR(DIC_CMD_LOCK),                       //锁车，1个字节
    ENUM_TO_STR(DIC_CMD_UNLOCK),                     //开锁，1个字节
    ENUM_TO_STR(DIC_CMD_BACK_NORMAL_WM),             //返回主界面

    ENUM_TO_STR(DIC_MC_CTL_TEMP),                    //控制器温度，2个字节,0.1C
    ENUM_TO_STR(DIC_MC_MOTOR_TEMP),                  //控制器电机温度，2个字节
    ENUM_TO_STR(DIC_MC_REM_TRIP),                    //控制器剩余里程，2个字节
    ENUM_TO_STR(DIC_MC_TORQUE_EN_CON),               //控制器力矩能量消耗，千卡，2个字节
    ENUM_TO_STR(DIC_MC_BAT_POWER_OFF),               //电池开关机状态，最高位为有效位，1个字节
    ENUM_TO_STR(DIC_MC_CADENCE),                    //踏频，单位rpm，2个字节
    ENUM_TO_STR(DIC_MC_TORQUE_VOLT),                //力矩输出电压，单位mv，2个字节
    ENUM_TO_STR(DIC_MC_MOTOR_SPEED),                //电机转速，单位rpm，1个字节
    ENUM_TO_STR(DIC_MC_MOTOR_MODE),                 //电机模式0x01-限速模式， 0x2-巡航模式， 0x3-推车模式， 0x4-坡行模式， 0x5-低速续航模式，默认值0Xff，1个字节
    ENUM_TO_STR(DIC_MC_POWER_OFF_BRAKE),            //断电刹车状态 0x01-刹把闭合，默认值0Xff，1个字节

    ENUM_TO_STR(DIC_MC_BUS_VOLTAGE),                //母线电压，0.1V，2个字节
    ENUM_TO_STR(DIC_MC_BUS_CURRENT),                //母线电流，0.1A，2个字节
    ENUM_TO_STR(DIC_MC_ROTATING_VOLTAGE),           //转把电压，0.1V，1个字节

    ENUM_TO_STR(DIC_MC_CTL_WORKING_STATUS),         //控制器工作状态，，1个字节
    ENUM_TO_STR(DIC_MC_CTL_ERROR_CODE),             //控制器错误码，，2个字节

    ENUM_TO_STR(DIC_MC_EEPROM_VER),                 //EEPROM版本号，6个字节
    ENUM_TO_STR(DIC_MC_CLEAR_TRIP),                 //清除行程计数，1个字节
    ENUM_TO_STR(DIC_MC_SOC),                        //电量百分比，1个字节
    //关于检修标志的管理数据结构
    //关于检修标志的管理数据结构
    ENUM_TO_STR(DIC_MAX_NUM),
};



//TAG 函数区
int16_t enum_to_addr(const uint8_t *data_len,uint16_t enum_value)
{
    int16_t addr_sum = 0;
    if(data_len[enum_value] != 0)
    {
        for(int i = 0; i < enum_value; i++)
        {
            addr_sum += data_len[i];
        }
    }
    else{ //只做参数配置信息，不做存储，不应该掉这个函数获取地址，应该报错
        ESP_LOGE(TAG, "enum_to_addr len iszero,no addr %d,%d\r\n",enum_value,data_len[enum_value]);
    }
    return addr_sum;
}
int16_t addr_to_enum(const uint8_t *data_len,uint16_t addr_value)
{
    int16_t addr_sum = 0;
    for(int16_t i = 0;; i++)
    {
        if(addr_sum == addr_value)return i;
        addr_sum += data_len[i];
        if(addr_sum > addr_value)
        {
           ESP_LOGE("APP", "addr_to_enum len iszero,no addr %d,%d\r\n",addr_value,data_len[i]); 
        }
    }
}
int8_t ec_app_enum_value_rw(uint8_t enum_value,void *data,uint8_t data_len,uint8_t r_or_w)
{
    int8_t ret = -1;
    uint8_t i;
    if(enum_value > DIC_MAX_NUM)
    {
        ret = 0;
        ESP_LOGE(TAG,"enum_value MAX:%d err = %d,",DIC_MAX_NUM,enum_value);
        return ret;
    }
    //找到枚举值的地址
    int16_t addr = enum_to_addr(ec_dic_data_len,enum_value);
    if(addr == -1)
    {
        ESP_LOGE(TAG,"enum_value err = %d",enum_value);
        return ret;
    }
    if(r_or_w == 1)//写，将数据写入到本地存储中
    {
        memcpy(&dic_data_buf[addr],data,data_len);
    }
    else//读取，从参数区读取数据保存到指定位置
    {
        memcpy(data,&dic_data_buf[addr],data_len);
    }
    ret = 0;
    return ret;
}

int8_t ec_app_param_get_value(uint8_t enum_value,void *data)
{
    return ec_app_enum_value_rw(enum_value,data,ec_dic_data_len[enum_value],NVS_READ);
}
int8_t ec_app_param_set_value(uint8_t enum_value,void *data)
{
    return ec_app_enum_value_rw(enum_value,data,ec_dic_data_len[enum_value],NVS_WRITE);
}
int8_t ec_app_get_dic_value(uint8_t enum_value)
{
    int16_t addr = enum_to_addr(ec_dic_data_len,enum_value);
    uint8_t data_len = ec_dic_data_len[enum_value];
    ESP_LOGI(TAG,"dic_addr:%d;dic_value:%s",addr,dic_value_string[enum_value]);
    for(int i = 0;i<data_len;i++)
    {
        ESP_LOGI(TAG,"data[%d] = %d,",i,dic_data_buf[addr+i]);
    }
    return 0;
}

esp_err_t ec_app_param_to_nvs(uint16_t nvs_key,uint8_t dir)
{

    esp_err_t  ret = ESP_OK;
    uint16_t addr = 0;//键值得首地址
    uint8_t data_len;//键值得数据长度
    if(nvs_key>=NVS_KEY_VALUE_MAX)
    {
        ESP_LOGE(TAG, "nuv-value error %d >= %d",nvs_key,NVS_KEY_VALUE_MAX);
    }
    switch(nvs_key)
    {
        case PARAM_VER:
            addr = 0;
            data_len = enum_to_addr(ec_dic_data_len,DIC_SYS_SN); 
        break;
        case SN_NUM:
            addr = enum_to_addr(ec_dic_data_len,DIC_SYS_SN);
            data_len = enum_to_addr(ec_dic_data_len,DIC_SYS_SPEED_LIMIT)-addr; 
        break;
        case CONFIG_PARAM:
            addr = enum_to_addr(ec_dic_data_len,DIC_SYS_SPEED_LIMIT);
            data_len = enum_to_addr(ec_dic_data_len,DIC_SYS_VOLTAGE_NUM)-addr; 
        break;
        case VOLTAGE_INFO:
            addr = enum_to_addr(ec_dic_data_len,DIC_SYS_VOLTAGE_NUM);
            data_len = enum_to_addr(ec_dic_data_len,DIC_SYS_PASSWORD_LEN)-addr; 
        break;
        case PASSWD_INFO:
            addr = enum_to_addr(ec_dic_data_len,DIC_SYS_PASSWORD_LEN);
            data_len = enum_to_addr(ec_dic_data_len,DIC_RUN_TRIP_TIME)-addr; 
        break;
        case RIDING_INFO:
            addr = enum_to_addr(ec_dic_data_len,DIC_RUN_TRIP_TIME);
            data_len = enum_to_addr(ec_dic_data_len,DIC_RUN_ODO_PAS1)-addr;//
        break;
        case PAS_RIDING_INFO:
            addr = enum_to_addr(ec_dic_data_len,DIC_RUN_ODO_PAS1);
            data_len = enum_to_addr(ec_dic_data_len,DIC_CALI_VOL_REF)-addr;//
        break;

        case CALI_INFO:
            addr = enum_to_addr(ec_dic_data_len,DIC_CALI_VOL_REF);
            data_len = enum_to_addr(ec_dic_data_len,DIC_BLE_NAME)-addr;//
            break;
        case BLE_INFO:
            addr = enum_to_addr(ec_dic_data_len,DIC_BLE_NAME);
            data_len = enum_to_addr(ec_dic_data_len,DIC_RUN_SYS_STATE)-addr;//
            break;
        default:
        break;
    }
    if(dir)
    {
        nvs_set_blob(nvs_handler, nvs_key_string[nvs_key], &dic_data_buf[addr], data_len);
        nvs_commit(nvs_handler);
    } 
    else{
        nvs_get_blob(nvs_handler, nvs_key_string[nvs_key], &dic_data_buf[addr], &data_len);
    }
    return ret;
}

//TAG 保存参数
void ec_app_save_nvs_param(uint16_t nvs_key)
{
    //读取参数去的数据
    ec_app_param_to_nvs(nvs_key,1);
}
void ec_app_param_save_key_value(uint16_t nvs_key)
{
    ec_app_param_to_nvs(nvs_key,1);
}
void *ec_app_param_get_dic_value_addr(uint8_t dic)
{
    return &dic_data_buf[enum_to_addr(ec_dic_data_len,dic)];
}
uint8_t ec_app_param_get_dic_value_8(uint8_t dic)
{
    return *(uint8_t *)ec_app_param_get_dic_value_addr(dic);
}
uint16_t ec_app_param_get_dic_value_16(uint8_t dic)
{
    return *(uint16_t *)ec_app_param_get_dic_value_addr(dic);
}
uint32_t ec_app_param_get_dic_value_32(uint8_t dic)
{
    return *(uint32_t *)ec_app_param_get_dic_value_addr(dic);

}
uint64_t ec_app_param_get_dic_value_64(uint8_t dic)
{
    return *(uint64_t *)ec_app_param_get_dic_value_addr(dic);
}
void ec_app_param_set_dic_value_8(uint8_t dic,uint8_t data){
    *(uint8_t *)ec_app_param_get_dic_value_addr(dic) = data;
}
void ec_app_param_set_dic_value_16(uint8_t dic,uint16_t data){
    *(uint16_t *)ec_app_param_get_dic_value_addr(dic) = data;
}
void ec_app_param_set_dic_value_32(uint8_t dic,uint32_t data){
    *(uint32_t *)ec_app_param_get_dic_value_addr(dic) = data;
}
void ec_app_param_set_dic_value_64(uint8_t dic,uint64_t data){
    *(uint32_t *)ec_app_param_get_dic_value_addr(dic) = data;
}
//TAG PARAM 初始化参数
void ec_app_param_init(void)
{
    esp_err_t   ret;
    uint16_t    enum_addr =0;
    uint8_t     param_ver = 0;
    size_t      read_len = 0;
    uint8_t     data_buf[8] = {0};
    if(enum_to_addr(ec_dic_data_len,DIC_MAX_NUM)>DIC_DATA_BUFF_SIZE)
    {
        ESP_LOGE(TAG,"enum data len = %d,buff size = %d",enum_to_addr(ec_dic_data_len,DIC_MAX_NUM),DIC_DATA_BUFF_SIZE);
    }
    ret = nvs_flash_init();
    if(ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND)
    {
        nvs_flash_erase();
        nvs_flash_init();
        ESP_LOGE(TAG,"nvs_flash_init err = %x",ret);
    }
    ESP_LOGI(TAG,"dic_data_buf addr @ %p",dic_data_buf);
    /*打开NVS设备*/
    ESP_ERROR_CHECK(nvs_open(NVS_NAMESPACE,NVS_READWRITE,&nvs_handler));
    //读取参数版本号，查看是否更新参数
//NOTE NVS写过别的数据，没有写入PARAM_VER信息
    //先读取是否有PARAM_VER，没有的话擦除NVS数据
    // 查询键是否存在
    size_t required_size = 0; // 用于保存键值的缓冲区大小
    ret = nvs_get_blob(nvs_handler, nvs_key_string[PARAM_VER], NULL, &required_size);
    if (ret == ESP_ERR_NVS_NOT_FOUND) {
        // 键不存在
        printf("Key '%s' not found!\n", nvs_key_string[PARAM_VER]);
        ec_app_param_reset();//参数恢复出厂

    }
    enum_addr = enum_to_addr(ec_dic_data_len,DIC_SYS_PARAM_VER);
    ec_app_param_to_nvs(PARAM_VER,0);//读取键值
    ESP_LOGI(TAG, "parameters ver: addr:%d,%x,%x",enum_addr,dic_data_buf[enum_addr],CFG_PARAM_VER);
    if(dic_data_buf[enum_addr] != CFG_PARAM_VER)//需要更新参数
    {
        ESP_LOGW(TAG, "restore_default_parameters: %x-->%x",dic_data_buf[enum_addr],CFG_PARAM_VER);
        ec_app_param_reset();
        ec_app_riding_reset_with_ODO();
    }
    ec_app_param_to_nvs(PARAM_VER,0);
    ESP_LOGI(TAG, "parameters ver: %x,%x",dic_data_buf[enum_addr],CFG_PARAM_VER);
    ec_app_get_nvs_param();//读取所有参数去的数据
    // ESP_LOG_BUFFER_HEX(TAG, dic_data_buf, 1024);
    // ESP_LOG_BUFFER_HEX(TAG, dic_data_buf_def, 1024);
//TAG 需要初始化的运行参数在这里初始化  
//开机档位设置成默认开机档位
    ec_app_param_get_value(DIC_SYS_POWERON_PAS_LEVEL,data_buf);
    ESP_LOGI(TAG, "DIC_SYS_POWERON_PAS_LEVEL: %d",data_buf[0]);
    ec_app_param_set_value(DIC_RUN_PAS,data_buf);//还需要同步到仪表信息

    data_buf[0] = 60;
    ec_app_param_set_value(DIC_SYS_EXTI_TIME,data_buf);//退出设置界面的时间
    ec_app_param_get_value(DIC_SYS_AUTO_OFF_TIME,data_buf);
    
    ESP_LOGI(TAG, "DIC_SYS_AUTO_OFF_TIME: %d",data_buf[0]); 
    ESP_LOGI(TAG, "DIC_SYS_SENSITIVITY_LEVEL: %d",*(uint8_t*)ec_app_param_get_dic_value_addr(DIC_SYS_SENSITIVITY_LEVEL));
    ESP_LOGI(TAG, "DIC_SYS_SOC_TYPE: %d",*(uint8_t*)ec_app_param_get_dic_value_addr(DIC_SYS_SOC_TYPE));
    ESP_LOGI(TAG, "DIC_SYS_BACKLIGHT: %d",*(uint8_t*)ec_app_param_get_dic_value_addr(DIC_SYS_BACKLIGHT));
    ESP_LOGI(TAG, "DIC_SYS_CURRENT_LIMIT: %d",*(uint16_t*)ec_app_param_get_dic_value_addr(DIC_SYS_CURRENT_LIMIT));
    ESP_LOGI(TAG, "DIC_BLE_NAME:%s",(char *)ec_app_param_get_dic_value_addr(DIC_BLE_NAME));
    ESP_LOGI(TAG, "DIC_CALI_VOL_REF:%ld",*(uint32_t*)ec_app_param_get_dic_value_addr(DIC_CALI_VOL_REF));
    ESP_LOGI(TAG, "DIC_RUN_ODO_CALORIE:%lld",*(uint64_t*)ec_app_param_get_dic_value_addr(DIC_RUN_ODO_CALORIE));
    ESP_LOGI(TAG, "DIC_RUN_TRIP_CALORIE:%lld",*(uint64_t*)ec_app_param_get_dic_value_addr(DIC_RUN_TRIP_CALORIE));
    ESP_LOGI(TAG, "DIC_SYS_LIFT_SPEED_LIMIT:%d",*(uint8_t *)ec_app_param_get_dic_value_addr(DIC_SYS_LIFT_SPEED_LIMIT));
}

void ec_app_get_nvs_param(void)//从nvs读取参数
{
    //读取参数去的数据
    ec_app_param_to_nvs(SN_NUM,0);
    ec_app_param_to_nvs(CONFIG_PARAM,0);
    ec_app_param_to_nvs(VOLTAGE_INFO,0);
    ec_app_param_to_nvs(PASSWD_INFO,0);
    ec_app_param_to_nvs(RIDING_INFO,0);
    ec_app_param_to_nvs(CALI_INFO,0);
    ec_app_param_to_nvs(BLE_INFO,0);
}

void ec_app_get_param(void)//从nvs读取参数
{
    //读取参数去的数据
    ec_app_param_to_nvs(SN_NUM,0);
    ec_app_param_to_nvs(CONFIG_PARAM,0);
    ec_app_param_to_nvs(VOLTAGE_INFO,0);
    ec_app_param_to_nvs(PASSWD_INFO,0);
    ec_app_param_to_nvs(RIDING_INFO,0);
    ec_app_param_to_nvs(CALI_INFO,0);
    ec_app_param_to_nvs(BLE_INFO,0);
}
//TAG PARAM 参数恢复出厂设置
void ec_app_param_reset(void)//把参数都设置为默认值
{
    uint8_t data_buf[32]= {0};
    //第一步、把默认参数中的数据复制到字典数据中（RAM中）
    memcpy(dic_data_buf,dic_data_buf_def,DIC_DATA_BUFF_SIZE);//先把默认的参数复制到字典数组中
    //第二步、处理一些数组数据
    ec_app_enum_value_rw(DIC_SYS_POWERON_PAS_LEVEL,&ec_config_pas_tab[CONFIG_DEF_PAS],1,NVS_WRITE);
    ec_app_enum_value_rw(DIC_SYS_PAS_TAB,ec_config_pas_tab,CONFIG_PAS_NUM,NVS_WRITE);

    //挡位信息的存储，1个字节存储挡位的数量，11个挡位存储挡位值
    switch(ec_config_pas_tab[CONFIG_PAS_NUM-1])//读取最大的档位值
    {
        case 3:
        ec_app_enum_value_rw(DIC_SYS_PAS_PWM_TAB,ec_config_pad_pwm_3_tab,3,NVS_WRITE);                    //档位PWM对应表
        break;
        case 5:
        ec_app_enum_value_rw(DIC_SYS_PAS_PWM_TAB,ec_config_pad_pwm_5_tab,5,NVS_WRITE);                    //档位PWM对应表
        break;
        case 7:
        ec_app_enum_value_rw(DIC_SYS_PAS_PWM_TAB,ec_config_pad_pwm_7_tab,7,NVS_WRITE);                    //档位PWM对应表
        break;
        case 9:
        ec_app_enum_value_rw(DIC_SYS_PAS_PWM_TAB,ec_config_pad_pwm_9_tab,9,NVS_WRITE);                    //档位PWM对应表
        break;
        default:break;
    }

    ec_app_enum_value_rw(DIC_SYS_VOLTAGE_TAB,ec_config_voltage_tab,CONFIG_VOLTAGE_NUM,NVS_WRITE);         //当前支持的电压列表
    for (size_t i = 0; i < CONFIG_VOLTAGE_NUM; i++)
    {
        ec_app_enum_value_rw(DIC_SYS_VOLTAGE_TAB_1+i,&ec_config_voltage_tab_value[i][0],24,NVS_WRITE);     //当前支持的电压列表
    }
    ec_app_enum_value_rw(DIC_SYS_VOLTAGE_PERC_TAB,ec_config_vol_perc_tab,10,NVS_WRITE);                    //当前支持的电压列表
    
    for (size_t i = 0; i < CONFIG_PASSWORD_LEN/2; i++)
    {
        //此处是小端
        data_buf[i] = (CONFIG_START_PASSWORD>>(8*i))&0xff;
    }
    ec_app_enum_value_rw(DIC_SYS_POWERON_PASSWORD,data_buf,CONFIG_PASSWORD_LEN,NVS_WRITE);                   //开机密码
    for (size_t i = 0; i < CONFIG_PASSWORD_LEN/2; i++)
    {
        //此处是小端
        data_buf[i] = (CONFIG_SETTING_PASSWORD>>(8*i))&0xff;
    }
    ec_app_enum_value_rw(DIC_SYS_SETTING_PASSWORD,data_buf,CONFIG_PASSWORD_LEN,NVS_WRITE);                   //设置密码
    for (size_t i = 0; i < CONFIG_PASSWORD_LEN/2; i++)
    {
        //此处是小端
        data_buf[i] = (CONFIG_USER_PASSWORD>>(8*i))&0xff;
    }
    ec_app_enum_value_rw(DIC_SYS_USER_PASSWORD,data_buf,CONFIG_PASSWORD_LEN,NVS_WRITE);

    //第三步、把RAM中的数据写入Flash的NVS中
    ec_app_param_to_nvs(PARAM_VER,1);
    ec_app_param_to_nvs(SN_NUM,1);
    ec_app_param_to_nvs(CONFIG_PARAM,1);
    ec_app_param_to_nvs(VOLTAGE_INFO,1);
    ec_app_param_to_nvs(PASSWD_INFO,1);
    ec_app_param_to_nvs(CALI_INFO,1);
    ec_app_param_to_nvs(BLE_INFO,1);
    nvs_commit(nvs_handler);
}
/******************************************************************************
** 功  能：复位骑行参数
** 参  数：pParam-指向骑行信息结构体的指针
** 返回值：无
** 备  注：ODO会清零
******************************************************************************/
void ec_app_riding_reset_with_ODO(void)
{
    uint8_t data_buf[8] = {0};
    ec_app_param_set_value(DIC_RUN_TRIP_TIME,data_buf);
    ec_app_param_set_value(DIC_RUN_TOTAL_TIME,data_buf);
    ec_app_param_set_value(DIC_RUN_SPEED_MAX,data_buf);
    ec_app_param_set_value(DIC_RUN_SPEED_AVG,data_buf);
    ec_app_param_set_value(DIC_RUN_ODO,data_buf);
    ec_app_param_set_value(DIC_RUN_TRIP,data_buf);
    ec_app_param_set_value(DIC_RUN_ODO_CALORIE,data_buf);
    ec_app_param_set_value(DIC_RUN_TRIP_CALORIE,data_buf);
    ec_app_param_set_value(DIC_RUN_ODO_PAS1,data_buf);
    ec_app_param_set_value(DIC_RUN_ODO_PAS2,data_buf);
    ec_app_param_set_value(DIC_RUN_ODO_PAS3,data_buf);
    ec_app_param_set_value(DIC_RUN_ODO_PAS4,data_buf);
    ec_app_param_set_value(DIC_RUN_ODO_PAS5,data_buf);
    ec_app_param_set_value(DIC_RUN_ODO_PAS6,data_buf);
    ec_app_param_to_nvs(RIDING_INFO,1);//骑行数据
    ec_app_param_to_nvs(PAS_RIDING_INFO,1);//档位骑行数据
}
/**
 * @brief 只清除小里程
 * 
 */
void ec_app_riding_reset_without_ODO(void)
{
    uint8_t data_buf[8] = {0};
    ec_app_param_set_value(DIC_RUN_TRIP_TIME,data_buf);
    ec_app_param_set_value(DIC_RUN_TOTAL_TIME,data_buf);
    ec_app_param_set_value(DIC_RUN_SPEED_MAX,data_buf);
    ec_app_param_set_value(DIC_RUN_SPEED_AVG,data_buf);
    ec_app_param_set_value(DIC_RUN_TRIP,data_buf);
    ec_app_param_set_value(DIC_RUN_ODO_CALORIE,data_buf);
    ec_app_param_set_value(DIC_RUN_TRIP_CALORIE,data_buf);
    ec_app_param_to_nvs(RIDING_INFO,1);//骑行数据
}
uint8_t ec_algorithm_cal_odo(uint16_t speed,uint8_t pas,uint16_t *speed_max,uint16_t *speed_avg,
        uint32_t *trip_time,uint32_t *total_time,uint64_t *trip,uint64_t *odo,uint64_t *pas_odo)
{
    if(speed>0)
    {
        if(*speed_max < speed)//是否更新最大速度
        {
            *speed_max = speed;
            
        }
        if(*speed_max > 999)//最大速度不得大于99.9
        {
            *speed_max = 999;
        }
        *trip_time = (*trip_time) + 1;
        *total_time = (*total_time) + 1;
        *trip = (*trip) + (speed * 10 / 36);//累加Trip里程，Trip里程的单位是分米
        *odo = (*odo) + (speed * 10 / 36);//累加ODO里程，单位：分米
        if((*trip_time) > 0)
		{
			*speed_avg = (*trip) * 36UL / (*trip_time) / 10UL;	/*计算平均速度，单位：分米/小时*/
		}
        *(pas_odo+pas)  = (*(pas_odo+pas)) + (speed * 10 / 36);//累加ODO里程，单位：分米
        if(*speed_avg > 999)//平均速度不得大于99.9
        {
            *speed_avg = 999;
        }
        ESP_LOGI("cal odo","speed %d,speed_max %d,speed_avg %d,*trip_time %ld,odo %lld,trip %lld",speed,*speed_max,*speed_avg,*trip_time,*odo,*trip);
        return 1;//返回骑行状态
    }
    return 0;//返回非骑行状态
}
/**
 * @brief 技术卡路里的函数
 * 
 * @param 	 assistLevel [in/out]，助力挡位
 * @param 	 workAssistRatio [in/out]，阻力比
 * @param 	 motorPower [in/out]，功率  
 * @param 	 speed [in/out]，速度   
 * @param 	 torque [in/out]，扭矩
 * @param 	 time [in/out]，时间
 * @return   uint16_t 
 * @warning	 【不可重入、阻塞等属性特殊说明】
 * @note	 【重大修改】
 * @version 0.1
 * @author zhao-jihai (sw12@key-display.com)
 * @date 2024-08-24
 * @copyright Copyright (c) 2024 天津柯迪斯
 */

uint16_t ec_param_cal_calories(uint8_t assistLevel, uint16_t workAssistRatio,
                uint16_t motorPower, uint16_t speed, uint16_t torque, uint16_t time)
{
    uint32_t uwPowerByPeople = 0; // 单位:W
    uint16_t uwCalories = 0; // 单位:卡
    float fCalCoff = 1 / 4.184; // 1 W = 1 kj/ms = 1 j/s; 1 卡 = 4.184 j
    // 计算人产生的功率
    if ( 0 == assistLevel )
    {
    // 无助力，根据速度进行计算， P=F*V; F=G*f; G是人与车的重量， f是摩擦系数
        uwPowerByPeople = 750UL * speed / 3600; // 750 * 0.01 * speed * 100.f / 3600
    }
    else
    {
        // 有助力，根据助力比与电机功率来进行计算，示例:助力比为3/1，表示电机出3份力，人出1份力
        uwPowerByPeople = workAssistRatio ? (motorPower / workAssistRatio) : 0;
    }
    //积分计算卡路里,单位:cal
    uwCalories = uwPowerByPeople * (time / 1000.0) * fCalCoff;
    // ESP_LOGE(TAG, "uwPowerByPeople:%ld, workAssistRatio:%d,motorPower:%d, assistLevel:%d, uwCalories:%d,time:%d",
    //          uwPowerByPeople, workAssistRatio, motorPower, assistLevel, uwCalories,time);
    return uwCalories;
}
uint8_t ec_app_pram_speed_cal_odo(void)
{
    uint16_t *speed;
    speed = (uint16_t *)&dic_data_buf[enum_to_addr(ec_dic_data_len,DIC_RUN_SPEED)];
    return ec_algorithm_cal_odo((*speed),dic_data_buf[enum_to_addr(ec_dic_data_len,DIC_RUN_PAS)],
                        (uint16_t *)&dic_data_buf[enum_to_addr(ec_dic_data_len,DIC_RUN_SPEED_MAX)],
                        (uint16_t *)&dic_data_buf[enum_to_addr(ec_dic_data_len,DIC_RUN_SPEED_AVG)],
                        (uint32_t *)&dic_data_buf[enum_to_addr(ec_dic_data_len,DIC_RUN_TRIP_TIME)],
                        (uint32_t *)&dic_data_buf[enum_to_addr(ec_dic_data_len,DIC_RUN_TOTAL_TIME)],
                        (uint64_t *)&dic_data_buf[enum_to_addr(ec_dic_data_len,DIC_RUN_TRIP)],
                        (uint64_t *)&dic_data_buf[enum_to_addr(ec_dic_data_len,DIC_RUN_ODO)],
                        (uint64_t *)&dic_data_buf[enum_to_addr(ec_dic_data_len,DIC_RUN_ODO_PAS1)]);
}
volatile const esp_partition_t *running_partition = NULL;//拿分区的指针
esp_app_desc_t running_app_info;
char *ec_app_param_get_version(void)
{
    running_partition = esp_ota_get_running_partition();
    if (running_partition == NULL) {
        ESP_LOGE(TAG, "Passive OTA partition not found");
    }
    else{
        
        if (esp_ota_get_partition_description(running_partition, &running_app_info) == ESP_OK) {
            ESP_LOGI(TAG, "Running firmware version: %s", running_app_info.version);
            ESP_LOGI(TAG, "Running Project_Name: %s", running_app_info.project_name);  
        }
    }
    return running_app_info.version;
}

